////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2017-2018 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// THIS IS AUTO-GENERATED CODE.  PLEASE DO NOT EDIT (File bug reports against tools).
///
/// Auto-generated by: ParameterParser V1.1.4
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  camxsensorcommon.h
/// @brief Auto-generated Chromatix parameter file
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef CAMXSENSORCOMMON_H
#define CAMXSENSORCOMMON_H

#include "parametermodule.h"
#include "parameterfilesymboltable.h"
#include "parametertypes.h"

#define CAMX_NAMESPACE_BEGIN namespace CamX {
#define CAMX_NAMESPACE_END }

CAMX_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// I2CFrequencyMode
/// Comments:      I2C frequency mode of slave
///                Supported modes are: STANDARD (100 KHz), FAST (400 KHz), FAST_PLUS (1 MHz), CUSTOM (Custom frequency in
///                DTSI)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class I2CFrequencyMode
{
    STANDARD  = 0,
    FAST      = 1,
    CUSTOM    = 2,
    FAST_PLUS = 3
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// I2CRegAddrDataType
///
/// Range:         [1,4]
/// Comments:      Register address / data size in bytes
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
typedef UINT32 I2CRegAddrDataType;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// OperationType
/// Comments:      Type of I2C operation
///                Valid values are: WRITE, WRITE_BURST, WRITE_SEQUENTIAL, READ, POLL
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class OperationType
{
    WRITE            = 0,
    WRITE_BURST      = 1,
    WRITE_SEQUENTIAL = 2,
    READ             = 3,
    POLL             = 4,
    MAX              = 5
};
/// Data that is associated with registerAddr
typedef UINT32 RegisterData;
/// List of data items in bytes seperated by space as delimiter.
/// Data may be written to an I2C slave in burst mode.
typedef UINT32**      RegisterDataList;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// RegisterSetting
/// Comments:      Register setting configuration
///                Contains: register address, register data, register address type, register data type,
///                operation and delay in micro seconds
///                 element for slaveAddr
///                 element for registerAddr
///                 element for registerData
///                 element for regAddrType
///                 element for regDataType
///                 element for operation
///                 element for delayUs
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct RegisterSetting
{
    /// Slave address to communicate with the device
    UINT32             slaveAddrExists;
    UINT32             slaveAddrID;
    UINT16             slaveAddr;
    /// Register address that is accessed
    UINT32             registerAddr;
    /// List of data items in bytes seperated by space as delimiter.
    /// Data may be written to an I2C slave in burst mode.
    /// If operation is WRITE, a single registerData item is to be written into location specified by registerAddr.
    /// For operation WRITE_BURST, a list of 1 or more registerData items will be written serially starting
    /// at the location specified by registerAddr, and the I2C slave will internally increment the address for each
    /// registerData item.
    /// For operation WRITE_SEQUENTIAL, a list of 1 or more registerData items will be written serially starting
    /// at the location specified by registerAddr, but the address is explicitly generated by the driver for each
    /// registerData item in the list.
    /// If operation is READ, registerData is the number of bytes to be read from the specified register address
    UINT32             registerDataCount;
    UINT32             registerDataID;
    RegisterData*      registerData;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// regAddrType
    ///
    /// Range:         [1,4]
    /// Comments:      Register address / data size in bytes
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    I2CRegAddrDataType regAddrType;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// regDataType
    ///
    /// Range:         [1,4]
    /// Comments:      Register address / data size in bytes
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    I2CRegAddrDataType regDataType;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// operation
    /// Default Value: WRITE
    /// Comments:      Type of I2C operation
    ///                Valid values are: WRITE, WRITE_BURST, WRITE_SEQUENTIAL, READ, POLL
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    OperationType      operation;
    /// Delay in micro seconds. Delay is 0 if not explicitly provided
    /// For operation WRITE, the delay value is applied at the end of the single register data item.
    /// For operation WRITE_BURST, WRITE_SEQUENTIAL, the delay value is applied at the end of the burst sequence.
    UINT32             delayUsExists;
    UINT32             delayUsID;
    UINT32             delayUs;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SettingsInfo
/// Comments:      Sequence of register settings to configure the device
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct SettingsInfo
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// regSetting - Array
    /// Min Length:    1
    /// Max Length:    Unbounded
    /// Comments:      Register setting configuration
    ///                Contains: register address, register data, register address type, register data type,
    ///                operation and delay in micro seconds
    ///                 element for slaveAddr
    ///                 element for registerAddr
    ///                 element for registerData
    ///                 element for regAddrType
    ///                 element for regDataType
    ///                 element for operation
    ///                 element for delayUs
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32           regSettingCount;
    UINT32           regSettingID;
    RegisterSetting* regSetting;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// PowerConfigurationType
/// Comments:      Power configuration type
///                Supported types are: MCLK, VANA, VDIG, VIO, VAF, RESET, STANDBY
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class PowerConfigurationType
{
    MCLK         = 0,
    VANA         = 1,
    VDIG         = 2,
    VIO          = 3,
    VAF          = 4,
    VAF_PWDN     = 5,
    CUSTOM_REG1  = 6,
    CUSTOM_REG2  = 7,
    RESET        = 8,
    STANDBY      = 9,
    CUSTOM_GPIO1 = 10,
    CUSTOM_GPIO2 = 11
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// PowerSetting
/// Comments:      Power setting configuration
///                Contains: configType, configValue and delay in milli seconds
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct PowerSetting
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// configType
    /// Comments:      Power configuration type
    ///                Supported types are: MCLK, VANA, VDIG, VIO, VAF, RESET, STANDBY
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    PowerConfigurationType configType;
    /// Configuration value for the type of configuration
    UINT32                 configValue;
    /// Delay in milli seconds
    UINT32                 delayMs;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// PowerSequenceInfo
/// Comments:      Sequence of power configuration type and configuration value required to control power to the device
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct PowerSequenceInfo
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// powerSetting - Array
    /// Min Length:    1
    /// Max Length:    Unbounded
    /// Comments:      Power setting configuration
    ///                Contains: configType, configValue and delay in milli seconds
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32        powerSettingCount;
    UINT32        powerSettingID;
    PowerSetting* powerSetting;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// FrameDimension
/// Comments:      Frame dimension: contains xStart, yStart, width and height
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct FrameDimension
{
    UINT32 xStart;
    UINT32 yStart;
    UINT32 width;
    UINT32 height;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Dimension
/// Comments:      Width and height of the frame or subframe
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct Dimension
{
    UINT32 width;
    UINT32 height;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Position
/// Comments:      Position information
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct Position
{
    UINT32 x;
    UINT32 y;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// camxsensorcommonClass
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class camxsensorcommonClass
{
public:

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load RegisterSetting
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadRegisterSetting(
        ParameterFileSymbolTableEntry* entry,
        RegisterSetting* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load SettingsInfo
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadSettingsInfo(
        ParameterFileSymbolTableEntry* entry,
        SettingsInfo* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load PowerSetting
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadPowerSetting(
        ParameterFileSymbolTableEntry* entry,
        PowerSetting* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load PowerSequenceInfo
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadPowerSequenceInfo(
        ParameterFileSymbolTableEntry* entry,
        PowerSequenceInfo* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load FrameDimension
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadFrameDimension(
        ParameterFileSymbolTableEntry* entry,
        FrameDimension* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load Dimension
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadDimension(
        ParameterFileSymbolTableEntry* entry,
        Dimension* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load Position
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadPosition(
        ParameterFileSymbolTableEntry* entry,
        Position* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload RegisterSetting
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadRegisterSetting(
        RegisterSetting* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload SettingsInfo
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadSettingsInfo(
        SettingsInfo* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload PowerSequenceInfo
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadPowerSequenceInfo(
        PowerSequenceInfo* structure);

}; // End class camxsensorcommonClass

CAMX_NAMESPACE_END
#endif // CAMXSENSORCOMMON_H

